home *** CD-ROM | disk | FTP | other *** search
/ MacGames Sampler / PHT MacGames Bundle.iso / MacSource Folder / Samples from the CD / Editors / emacs / Emacs-1.14b1-sources / sources / unix-emulation-src / stdio1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-23  |  8.1 KB  |  543 lines  |  [TEXT/EMAC]
  1. /*
  2.  * Copyright (C) 1993, 1994 Marc Parmet.
  3.  * This file is part of the Macintosh port of GNU Emacs.
  4.  *
  5.  * GNU Emacs is distributed in the hope that it will be useful,
  6.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  7.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  8.  * GNU General Public License for more details.
  9.  */
  10.  
  11. #if defined(THINK_C)
  12. #include <MacHeaders>
  13. #else
  14. #include <Types.h>
  15. #include <Memory.h>
  16. #include <Quickdraw.h>
  17. #include <Windows.h>
  18. #endif
  19.  
  20. #include <stdarg.h>
  21. #include "stdio.h"
  22. #include "errno.h"
  23. #include "sys/file.h"
  24. #include "sys/stat.h"
  25.  
  26. extern int errno;
  27.  
  28. void
  29. vprintf(char *fmt,va_list ap)
  30. {
  31.     vfprintf(stdout,fmt,ap);
  32. }
  33.  
  34. void
  35. vsprintf(char *dest,char *fmt,va_list ap)
  36. {
  37.     FILE f;
  38.  
  39.     f.cnt = 0;
  40.     f.base = (unsigned char *)dest;
  41.     f.fd = -1;
  42.     f.flag = _WRITE;
  43.     f.err = 0;
  44.     f.buflen = 0x7fffffff;
  45.     f.havepushback = 0;
  46.     f.havespec = 0;
  47.     vfprintf(&f,fmt,ap);
  48.     f.base[f.cnt] = '\0';
  49. }
  50.  
  51. void
  52. fprintf(FILE *fp,char *fmt,...)
  53. {
  54.     va_list ap;
  55.  
  56.     va_start(ap,fmt);
  57.     vfprintf(fp,fmt,ap);
  58.     va_end(ap);
  59. }
  60.  
  61. void
  62. printf(char *fmt,...)
  63. {
  64.     va_list ap;
  65.  
  66.     va_start(ap,fmt);
  67.     vfprintf(stdout,fmt,ap);
  68.     va_end(ap);
  69. }
  70.  
  71. void
  72. sprintf(char *s,char *fmt,...)
  73. {
  74.     va_list ap;
  75.  
  76.     va_start(ap,fmt);
  77.     vsprintf(s,fmt,ap);
  78.     va_end(ap);
  79. }
  80.  
  81. void
  82. fdopen_internal(int fd,char *mode,FILE *fp)
  83. {
  84.     int i;
  85.  
  86.     if (*mode != 'w' && *mode != 'r' && *mode != 'a') {
  87.         fprintf(stderr,"Illegal mode %s in fopen or fdopen.\012",mode);
  88.         return;
  89.     }
  90.     
  91.     fp->fd = fd;
  92.     fp->base = (unsigned char *)NewPtr(BUFSIZ);
  93.     fp->external_base = 0;
  94.     fp->flag = (*mode == 'r' ? _READ : _WRITE);
  95.     fp->cnt = 0;
  96.     fp->buflen = BUFSIZ;
  97.     fp->err = 0;
  98.     fp->havespec = 0;
  99. }
  100.  
  101. FILE *
  102. fdopen(int fd,char *mode)
  103. {
  104.     int i;
  105.     FILE *fp;
  106.  
  107.     for (i = 0; i<_NFILE; ++i)
  108.         if (_iob(i)->flag == 0)
  109.             break;
  110.     
  111.     if (i == _NFILE) { errno = EUNDOC; return 0L; }
  112.     fp = _iob(i);
  113.     fdopen_internal(fd,mode,fp);
  114.     return fp;
  115. }
  116.  
  117. static int
  118. mode_to_perm(char *name,char *mode)
  119. {
  120.     switch (*mode) {
  121.     case 'r': return O_RDONLY;
  122.     case 'w': return O_WRONLY;
  123.     case 'a': return O_WRONLY;
  124.     default:
  125.         fprintf(stderr,"Illegal mode \"%s\" opening %s\012",mode,name);
  126.         return -1;
  127.     }
  128. }
  129.  
  130. FILE *
  131. fopen(char *name,char *mode)
  132. {
  133.     FILE *fp;
  134.     int created;
  135.     int i,fd,perm;
  136.     
  137.     perm = mode_to_perm(name,mode);
  138.     if (perm == -1) return 0L;
  139.     
  140.     created = 0;
  141.     if (*mode == 'w') {
  142.         fd = creat(name,perm);
  143.         created = 1;
  144.     }
  145.     else if (*mode == 'a') {
  146.         fd = open(name,perm);
  147.         if (fd == -1) {
  148.             fd = creat(name,perm);
  149.             created = 1;
  150.         }
  151.         lseek(fd,0,2);
  152.     }
  153.     else
  154.         fd = open(name,perm);
  155.     
  156.     if (fd == -1) { errno = EUNDOC; return 0L; }
  157.     fp = fdopen(fd,mode);
  158.     if (fp == 0L) {
  159.         close(fd);
  160.         if (created)
  161.             unlink(name);
  162.         errno = EUNDOC;
  163.     }
  164.     fp->havespec = unixfn2FSSpec(name,&fp->spec) == 0;
  165.     return fp;
  166. }
  167.  
  168. FILE *
  169. freopen(char *name,char *mode,FILE *fp)
  170. {
  171.     int i,fd,created,perm;
  172.     
  173.     fclose(fp);
  174.  
  175.     perm = mode_to_perm(name,mode);
  176.     if (perm == -1) return 0L;
  177.     
  178.     created = 0;
  179.     if (*mode == 'w') {
  180.         fd = creat(name,perm);
  181.         created = 1;
  182.     }
  183.     else if (*mode == 'a') {
  184.         fd = open(name,perm);
  185.         if (fd == -1) {
  186.             fd = creat(name,perm);
  187.             created = 1;
  188.         }
  189.         lseek(fd,0,2);
  190.     }
  191.     else
  192.         fd = open(name,perm);
  193.     
  194.     if (fd == -1) { errno = EUNDOC; return 0L; }
  195.     fdopen_internal(fd,mode,fp);
  196.     fp->havespec = unixfn2FSSpec(name,&fp->spec) == 0;
  197.     return fp;
  198. }
  199.  
  200. void
  201. setbuf(FILE *fp,char *p)
  202. {
  203.     if (fp->base && !fp->external_base) DisposPtr((Ptr)fp->base);
  204.     fp->base = (unsigned char *)p;
  205.     fp->external_base = 1;
  206.     fp->cnt = 0;
  207.     fp->buflen = p ? BUFSIZ : 0;
  208. }
  209.  
  210. int min(a,b) { return a<b ? a : b; }
  211.  
  212. static void
  213. initbuf(FILE *fp)
  214. {
  215.     if (fp->base == 0L && (fp->flag & _AUTO)) {
  216.         char *t = NewPtr(BUFSIZ);
  217.         setbuf(fp,t);
  218.     }
  219. }
  220.  
  221. int
  222. fread(char *p,int size,int items,FILE *fp)
  223. {
  224.     int i,n,k,take;
  225.     char *t;
  226.  
  227.     initbuf(fp);
  228.  
  229.     if (fp->base) {
  230.         for (i = 0; i<items; ++i) {
  231.             k = 0;
  232.             while (1) {
  233.                 take = min(size,fp->cnt);
  234.                 memcpy(p + i*size + k,fp->base + (fp->buflen - fp->cnt),take);
  235.                 k += take;
  236.                 fp->cnt -= take;
  237.                 
  238.                 if (k == size) break;
  239.  
  240.                 if (fp->fd < 0) { fp->err = errno = EEOF; return i; }
  241.                 n = read(fp->fd,fp->base,BUFSIZ);
  242.                 if (n == -1 || n == 0) {
  243.                     fp->err = errno = EEOF;
  244.                     return i;
  245.                 }
  246.                 fp->buflen = fp->cnt = n;
  247.             }
  248.         }
  249.     }
  250.     else {
  251.         for (i = 0; i<items; ++i) {
  252.             if (fp->fd < 0) { fp->err = errno = EEOF; return i; }
  253.             n = read(fp->fd,p + i*size,size);
  254.             if (n == -1) {
  255.                 fp->err = errno = EUNDOC;
  256.                 return i;
  257.             }
  258.             else if (n < size) {
  259.                 fp->err = errno = EEOF;
  260.                 return i;
  261.             }
  262.         }
  263.     }
  264.     
  265.     errno = fp->err = 0;
  266.     return i;
  267. }
  268.  
  269. int
  270. fwrite(char *p,int size,int items,FILE *fp)
  271. {
  272.     int i,k,n,put;
  273.     char *t;
  274.  
  275.     initbuf(fp);
  276.     
  277.     if (fp->base) {
  278.         for (i = 0; i<items; ++i) {
  279.             k = 0;
  280.             while (1) {
  281.                 put = min(size,fp->buflen - fp->cnt);
  282.                 memcpy(fp->base + fp->cnt,p + i*size + k,put);
  283.                 k += put;
  284.                 fp->cnt += put;
  285.                 
  286.                 if (k == size) break;
  287.  
  288.                 if (fp->fd < 0) { fp->err = errno = EEOF; return 0; }
  289.                 n = write(fp->fd,fp->base,fp->buflen);
  290.                 if (n == -1) {
  291.                     fp->err = errno = EUNDOC;
  292.                     return i;
  293.                 }
  294.                 else if (n != fp->buflen) {
  295.                     fp->err = errno = EEOF;
  296.                     return i;
  297.                 }
  298.                 fp->cnt = 0;
  299.             }
  300.         }
  301.     }
  302.     else {
  303.         for (i = 0; i<items; ++i) {
  304.             if (fp->fd < 0) { fp->err = errno = EEOF; return 0; }
  305.             n = write(fp->fd,p + i*size,size);
  306.             if (n == -1) {
  307.                 fp->err = errno = EUNDOC;
  308.                 return i;
  309.             }
  310.             else if (n != size) {
  311.                 fp->err = errno = EEOF;
  312.                 return i;
  313.             }
  314.         }
  315.     }
  316.     
  317.     fp->err = errno = 0;
  318.      return i;
  319. }
  320.  
  321. int
  322. _putc(int c,FILE *fp)
  323. {
  324.     int n;
  325.     
  326.     initbuf(fp);
  327.  
  328.     if (fp->base) {
  329.         if (fp->cnt == fp->buflen) {
  330.             if (fp->fd < 0) { fp->err = errno = EEOF; return -1; }
  331.             n = write(fp->fd,fp->base,fp->buflen);
  332.             if (n != fp->buflen) {
  333.                 errno = fp->err = EEOF;
  334.                 return EOF;
  335.             }
  336.             fp->cnt = 0;
  337.         }
  338.         fp->base[fp->cnt++] = c;
  339.         errno = fp->err = 0;
  340.         return c;
  341.     }
  342.     else {
  343.         char d = c;
  344.         if (fp->fd < 0) { fp->err = errno = EEOF; return -1; }
  345.         n = write(fp->fd,&d,1);
  346.         if (n != 1) {
  347.             errno = fp->err = EEOF;
  348.             return EOF;
  349.         }
  350.         else {
  351.             errno = fp->err = 0;
  352.             return c;
  353.         }
  354.     }
  355. }
  356.  
  357. int
  358. _getc(FILE *fp)
  359. {
  360.     int i,n;
  361.     unsigned char c;
  362.     
  363.     if (fp->havepushback) {
  364.         fp->havepushback = 0;
  365.         return fp->pushback;
  366.     }
  367.     
  368.     initbuf(fp);
  369.  
  370.     if (fp->base) {
  371.         if (fp->cnt == 0) {
  372.             n = fread((char *)&c,1,1,fp);
  373.             if (n == 0) {
  374.                 errno = fp->err = EEOF;
  375.                 return EOF;
  376.             }
  377.             else {
  378.                 errno = fp->err = 0;
  379.                 return c;
  380.             }
  381.         }
  382.         else {
  383.             errno = fp->err = 0;
  384.             return fp->base[fp->buflen - fp->cnt--];
  385.         }
  386.     }
  387.     else {
  388.         if (fp->fd < 0) { fp->err = errno = EEOF; return -1; }
  389.         n = read(fp->fd,&c,1);
  390.         if (n == 1) {
  391.             errno = fp->err = 0;
  392.             return c;
  393.         }
  394.         else {
  395.             errno = fp->err = EEOF;
  396.             return EOF;
  397.         }
  398.     }
  399. }
  400.  
  401. int
  402. fputc(int c,FILE *fp)
  403. {
  404.     return putc(c,fp);
  405. }
  406.  
  407. int
  408. feof(FILE *fp)
  409. {
  410.     return fp->err == EEOF;
  411. }
  412.  
  413. void
  414. clearerr(FILE *fp)
  415. {
  416.     fp->err = 0;
  417. }
  418.  
  419. int
  420. ungetc(int c,FILE *fp)
  421. {
  422.     fp->havepushback = 1;
  423.     fp->pushback = c;
  424.     return c;
  425. }
  426.  
  427. int
  428. fileno(FILE *fp)
  429. {
  430.     return fp->fd;
  431. }
  432.  
  433. char *
  434. fgets(char *s, int n, FILE *fp)
  435. {
  436.     int c;
  437.     char *t = s;
  438.     
  439.     if (n < 1) return 0L;
  440.     while (--n) {
  441.         if ((c = getc(fp)) < 0) {
  442.             if (fp->err == EEOF && t != s)
  443.                 break;
  444.             return 0L;
  445.         }
  446.         *t++ = c;
  447.         if (c == 10) /* '\012' */
  448.             break;
  449.     }
  450.     *t = '\0';
  451.     return(s);
  452. }
  453.  
  454. int
  455. fsync()
  456. {
  457.     /* fclose will flush. */
  458.     return 0;
  459. }
  460.  
  461. void
  462. fputs(char *s,FILE *fp)
  463. {
  464.     char c;
  465.     
  466.     while (1) {
  467.         c = *s++;
  468.         if (c == '\0') return;
  469.         putc(c,fp);
  470.     }
  471. }
  472.  
  473. void
  474. perror(const char *s)
  475. {
  476.     int i = errno;
  477.     
  478.     if (s && *s)
  479.         fprintf(stderr, "%s: ", s);
  480.     fprintf(stderr, "Error %d", i);
  481.     fputc(10, stderr); /* '\012' */
  482. }
  483.  
  484. int
  485. fstat(FILE *fp,struct stat *st)
  486. {
  487.     if (!fp->havespec) { errno = EUNDOC; return -1; }
  488.     return stat_spec(&fp->spec,st);
  489. }
  490.  
  491. void
  492. puts(char *s)
  493. {
  494.     printf("%s\012",s);
  495. }
  496.  
  497. void
  498. rewind(FILE *fp)
  499. {
  500.     if (fp->fd < 0) return;
  501.     lseek(fp->fd,0,0);
  502.     fp->err = 0;
  503.     fp->cnt = 0;
  504. }
  505.  
  506. int
  507. fseek(FILE *fp,int offset,int whence)
  508. {
  509.     fp->err = 0;
  510.     fp->cnt = 0;
  511.     fp->havepushback = 0;
  512.     if (fp->fd < 0) { fp->err = errno = EEOF; return -1; }
  513.     return lseek(fp->fd,offset,whence);
  514. }
  515.  
  516. int
  517. ferror(FILE *fp)
  518. {
  519.     return fp->err;
  520. }
  521.  
  522. int
  523. ftell(FILE *fp)
  524. {
  525.     int tell_result;
  526.     if (fp->fd < 0) { fp->err = errno = EEOF; return -1; }
  527.     tell_result = tell(fp->fd);
  528.     if (tell_result == -1) return -1;
  529.     return tell_result - fp->cnt;
  530. }
  531.  
  532. FILE *
  533. popen(char *name,char *mode)
  534. {
  535.     return 0L;
  536. }
  537.  
  538. int
  539. pclose(FILE *fp)
  540. {
  541.     return -1;
  542. }
  543.